// 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

// 上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 感谢 Marcos 贡献此图。

// 示例:

// 输入: [0,1,0,2,1,0,1,3,2,1,2,1]
// 输出: 6

#include "../stdc++.h"

// 单调栈
// 时间复杂度：O(n)
// 空间复杂度：O(n)
class Solution {
public:
    int trap(vector<int>& height) {
        stack<int> stk{}; // 单调递减的栈
        int n = height.size();
        int res{0};
        for (int i{0}; i < n; ++i) {
            while (!stk.empty() && height[stk.top()] < height[i]) {
                int topIndex = stk.top();
                stk.pop();
                // 检查栈是否为空，如果是空，则说明左边已经没有了
                if (stk.empty()) {
                    break;
                }
                int leftIndex = stk.top();
                int w = i - leftIndex - 1;
                int h = min(height[leftIndex], height[i]) - height[topIndex];
                res += w * h;
            }
            stk.push(i);
        }
        return res;
    }
};

// 动态规划
// 时间复杂度：O(n)
// 空间复杂度：O(n)
class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        if (n <= 2) {
            return 0;
        }
        vector<int> leftMax(n, 0); // 左边最高高度
        leftMax[0] = height[0];
        for (int i{1}; i < n; ++i) {
            leftMax[i] = max(leftMax[i - 1], height[i]);
        }
        vector<int> rightMax(n, 0);
        rightMax[n - 1] = height[n - 1];
        for (int i{n - 2}; i >= 0; --i) {
            rightMax[i] = max(rightMax[i + 1], height[i]);
        }
        int res{0};
        for (int i{0}; i < n; ++i) {
            res += min(leftMax[i], rightMax[i]) - height[i];
        }
        return res;
    }
};

// 双指针
// 时间复杂度：O(n)
// 空间复杂度：O(1)
class Solution {
public:
    int trap(vector<int>& height) {
        int res{0};
        int left{0};
        int right = height.size() - 1;
        int leftMax{0};
        int rightMax{0};
        while (left < right) {
            leftMax = max(leftMax, height[left]);
            rightMax = max(rightMax, height[right]);
            if (height[left] < height[right]) {
                res += leftMax - height[left];
                ++left;
            } else {
                res += rightMax - height[right];
                --right;
            }
        }
        return res;
    }
};
